/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Fuente;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Random;
import javax.swing.ImageIcon;
import javax.swing.JLabel;

/**
 *
 * @author Julio Lemus
 */
public class Juego {
    int Jugador; //true: atacante; false: equilibrista
    private int Turno;
    private int Peso; // 1-11
    private int Estado; // 0: juego no iniciado; 1: juego iniciado; 2: gano server; 3: gano cliente
    JLabel lblNum, lblJg1, lblJg2, lblRes, lblGrado, lblNomJ, lblGan_Tit;
    String[] fichas_path;
    
    ///////////////Parte del tablero
    public static final int   CANTIDAD_FILAS_DEFECTO    = 5;
    private int canidadColumnas ,
                cantidadFilas;
    private Casilla[] matrizTablero;
    
    public minmax MinMax;
    
    /////////////////////////////////////////////////////////////////////
    
    
    //Server: Atacante
    //Cliente: Equilibrista
    
    public Juego(JLabel lbln, JLabel lj1,JLabel lj2, JLabel lr, JLabel lg,
            JLabel lblnom, JLabel lblgt, int est, int jg){
        this.lblNum = lbln;
        this.lblJg1 = lj1;
        this.lblJg2 = lj2;
        this.lblRes = lr;
        this.lblGrado = lr;
        this.lblNomJ = lblnom;
        this.lblGan_Tit = lblgt;
        this.Estado = est;
        this.Jugador = jg;
        this.Turno = 1;
        this.Peso = 0;
        fichas_path = new String[13];
        Fichas_Path_();
        
        /////////////// Parte del tablero 
        this.cantidadFilas      = Juego.CANTIDAD_FILAS_DEFECTO;
        this.cagarMatrizTablero();
        this.restarurarTablero();
    }

    private Juego() {
         this.cantidadFilas      = Juego.CANTIDAD_FILAS_DEFECTO;
        this.cagarMatrizTablero();
        this.restarurarTablero();
    }
private void cagarMatrizTablero(){
    // ------------------------------------------------------------------

        int columna, fila;

    // ------------------------------------------------------------------

        this.matrizTablero  = new Casilla[ this.cantidadFilas ];

        for( fila =0; fila < this.cantidadFilas; fila++ ){
            
                this.matrizTablero[ fila ] = new Casilla( fila);
            
        }
        
    }

    public void restarurarTablero(){
    // ----------------------------------------------------------------
        int columna, fila;
    // ----------------------------------------------------------------

        for( fila =0; fila < this.cantidadFilas; fila++ ){
            
                this.matrizTablero[ fila ].deshabilitar();
            
        }

     }
public int getCantidadFilas() {
        return cantidadFilas;
    }

 
    public void setCantidadFilas(int cantidadFilas) {
        this.cantidadFilas = cantidadFilas;
    }


    public Casilla[] getMatrizTablero() {
        return matrizTablero;
    }

    
     public void setMatrizTablero(Casilla[] matrizTablero) {
        this.matrizTablero = matrizTablero;
    }

    public boolean ponerPeso(Casilla cas) { /////// poner la ficha dentro del tablero
          
          ArrayList pivotes;
          Iterator it;
          int icon =  cas.obtenerColorFicha();
          

          //comprobar que el destino está vacío
          if (matrizTablero[cas.fila].obtenerColorFicha() != Casilla.TRANSPARENTE)
             return false;

          //buscar la/s ficha/s que hace/n de pivote
          pivotes = crearListaPivotes(cas, icon);

          //si no hay pivotes, el movimiento no es válido
          if (pivotes.isEmpty())
             return false;

          //si hay pivotes, se deben cambiar de color las fichas entre la posición
          //actual y cada uno de los pivotes
          it = pivotes.iterator();
          while (it.hasNext()) {
             voltearFichas(cas, (Casilla)it.next(),icon);
          }

          //colocar la nueva ficha en el tablero
          if (icon == Casilla.EQUILIBRSITA)
              matrizTablero[cas.fila].asignarFichaBlanca();
          else
               matrizTablero[cas.fila].asignarFichaNegra();
          return true;
   }

    private ArrayList crearListaPivotes(Casilla cas, int icon) {
          ArrayList pivotes;
          Casilla piv;
          int incFila, incCol;

          pivotes = new ArrayList();
          //recorrer las 8 direcciones posibles
          for (incFila=-1; incFila<=1; incFila++)
             for (incCol=-1; incCol<=1; incCol++)
                if ((incCol!=0)||(incFila!=0)) {
                   //buscar un pivote en esa dirección
                   piv = buscarPivote(cas, incFila, incCol, icon);
                   if (piv!=null)
                      pivotes.add(piv);
                }

      return pivotes;
   }

   private Casilla buscarPivote(Casilla cas, int incFila, int incCol, int icon) {
          int f,c;

          //a partir de dónde se empieza a buscar el pivote
          f = cas.fila + incFila;
          //c = cas.col + incCol;

          //no buscar el pivote fuera del tablero
          if ((f<0)||(f>5))
             return null;

          //tiene que haber al menos una ficha del color contrario que "flanquear"
          //entre la nueva ficha y el pivote
          if ((matrizTablero[f].obtenerColorFicha() == Casilla.TRANSPARENTE)||((matrizTablero[f].obtenerColorFicha()==icon)))
             return null;

          //buscar y devolver posición del pivote
          while ((f>=0)&&(f<5)) {
         //hemos llegado a una casilla vacía, no hay pivote
             if (matrizTablero[f].obtenerColorFicha() == Casilla.TRANSPARENTE)
                return null;
             //pivote encontrado (ficha del mismo color)
             if (matrizTablero[f].obtenerColorFicha()==icon)
                return new Casilla(f);
             //siguiente casilla
             f += incFila;
             
          }

          //no se ha encontrado pivote
          return null;
   }

    private void voltearFichas(Casilla cas, Casilla pivote, int icon) {

                  
   }


     public boolean  EsFinalDeJuego()
    {
        if (PuedeJugar(Casilla.ATACANTE) || PuedeJugar(Casilla.EQUILIBRSITA))
            return false;
        else
            return true;
    }


      public  int Puntos(int playerColor)
      {
            int points = 0;

            for (int x = 0; x < Juego.CANTIDAD_FILAS_DEFECTO; x++)
               
                    if (matrizTablero[x].obtenerColorFicha() == playerColor)
                    {
                        points++;
                    }

            return points;
     }

    public boolean  PuedeJugar(int player)
      {
        
        return false;
      }
      public boolean movLegal(Casilla c) {
              int incFila, incCol;

              
              return false;
      }


    public ArrayList<Casilla> generarMovimiento(int jugador)
    {
        
        return null;
    }

    public int valorMovimiento(Casilla cas, int jugador)
        {
            

            return 0;
        }

     public boolean  espacioValido(int fila, int col)
    {
        return true;
    }
     public void imprimirTablero()
     {
         
     } 
      public Juego copiarTablero()
     {
         Juego nuevoTablero=new Juego();
         Casilla[] nuevaCasillas= new Casilla[CANTIDAD_FILAS_DEFECTO];
         for(int  fila =0; fila < Juego.CANTIDAD_FILAS_DEFECTO; fila++ ){

            
                nuevaCasillas[fila]= (matrizTablero[fila]).copiarCasilla();

            
         }
         nuevoTablero.setMatrizTablero(nuevaCasillas);
         return nuevoTablero;
     }
      
  //////////////////////    Final de Tablero ///////////////////////////////////////////////////////
      
      
    public void AsignarFicha(){
        try{
            if (Estado == 1){
                Random r = new Random();
                int n = 0;
                do{
                    n = r.nextInt(11+1);
                }while (n==0);
                System.out.println("Numero: " + n + "\t Imagen Path: "+ fichas_path[n]);
                lblNum.setIcon(new ImageIcon(getClass().getResource(fichas_path[n])));
                setPeso(n);
                if (Jugador == 0){
                    lblJg2.setIcon(new ImageIcon(getClass().getResource(fichas_path[n])));
                    lblNomJ.setText("Atacante");
                }else if (Jugador == 1){
                    lblJg1.setIcon(new ImageIcon(getClass().getResource(fichas_path[n])));
                    lblNomJ.setText("Equilibrista");
                } 
                EvaluarGanador();
            }
        }catch (Exception e){
            System.err.println(e);
        }
    }
    
    private void EvaluarGanador(){
        try{
            if (Estado == 1){
                if (Turno == 10 && Jugador == 1){
                    lblGan_Tit.setVisible(true);
                    lblRes.setText("Equilibrista");
                    Estado = 2;
                }
            }
        }catch(Exception e){
            System.err.println("Error: "+ e.getMessage());
        }
    }
    
               
    
    private void Fichas_Path_(){
        if (fichas_path != null){
            fichas_path[0] = "/Imagenes/img_0.jpg";
            fichas_path[1] = "/Imagenes/img_1.jpg";
            fichas_path[2] = "/Imagenes/img_2.jpg";
            fichas_path[3] = "/Imagenes/img_3.jpg";
            fichas_path[4] = "/Imagenes/img_4.jpg";
            fichas_path[5] = "/Imagenes/img_5.jpg";
            fichas_path[6] = "/Imagenes/img_6.jpg";
            fichas_path[7] = "/Imagenes/img_7.jpg";
            fichas_path[8] = "/Imagenes/img_8.jpg";
            fichas_path[9] = "/Imagenes/img_9.jpg";
            fichas_path[10] = "/Imagenes/img_10.jpg";
            fichas_path[11] = "/Imagenes/img_11.jpg";
            fichas_path[12] = "/Imagenes/question.jpg";
            
        }
    }

    /**
     * @return the Turno
     */
    public int getTurno() {
        return Turno;
    }

    /**
     * @param Turno the Turno to set
     */
    public void setTurno(int Turno) {
        this.Turno = Turno;
    }

    /**
     * @return the Estado
     */
    public int getEstado() {
        return Estado;
    }

    /**
     * @param Estado the Estado to set
     */
    public void setEstado(int Estado) {
        this.Estado = Estado;
    }

    /**
     * @return the Peso
     */
    public int getPeso() {
        return Peso;
    }

    /**
     * @param Peso the Peso to set
     */
    public void setPeso(int Peso) {
        this.Peso = Peso;
    }
     
    public int setMinMaxProfundidad (){
        return MinMax.getProfundidad();
    }
}
